import Cookies from 'js-cookie'
import { Message } from 'element-ui'
import moment from 'moment'
let util = {}

// 判断对象非空
util.notNull = obj => {
    if (obj !== '' && obj !== ' ' && obj !== undefined && obj !== null) {
        return true
    }
    return false
}
// 根据对象key排序对象
util.objKeySort = obj => {
    // 排序的函数
    var newkey = Object.keys(obj).sort()
    // 先用Object内置类的keys方法获取要排序对象的属性名，再利用Array原型上的sort方法对获取的属性名进行排序，newkey是一个数组
    var newObj = {}
    // 创建一个新的对象，用于存放排好序的键值对
    for (var i = 0; i < newkey.length; i++) {
        // 遍历newkey数组
        newObj[newkey[i]] = obj[newkey[i]]
        // 向新创建的对象中按照排好的顺序依次增加键值对
    }
    return newObj
    // 返回排好序的新对象
}
// 判断对象为空
util.isEmpty = str => {
    if (str === '' || str === undefined || str === null) {
        return true
    }
    return false
}
util.remove = (arr, val) => {
    let index = arr.indexOf(val)
    if (index > -1) {
        arr.splice(index, 1)
    }
}
// 验证值是否合法
util.verifyValue = (type, value, displayname) => {
    if (value === '') {
        Message({ showClose: true, message: `请输入${displayname}`, type: 'error', duration: 2000 })
        return false
    }
    if (type === 'GisData') {
        let regxLongitude = /^-?((0|1?[0-7]?[0-9]?)(([.][0-9]{1,4})?)|180(([.][0]{1,4})?))$/
        let regxLatitude = /^-?((0|[1-8]?[0-9]?)(([.][0-9]{1,4})?)|90(([.][0]{1,4})?))$/
        if (value.address === '') {
            Message({ showClose: true, message: '请输入地理位置', type: 'error', duration: 2000 })
            return false
        }
        if (value.longitude === '' || !regxLongitude.test(value.longitude)) {
            Message({ showClose: true, message: '请输入合法的经度', type: 'error', duration: 2000 })
            return false
        }
        if (value.latitude === '' || !regxLatitude.test(value.latitude)) {
            Message({ showClose: true, message: '请输入合法的纬度', type: 'error', duration: 2000 })
            return false
        }
    } else if (type === 'TimeInterval') {
        if (value.startTime === '') {
            Message({ showClose: true, message: '请输入开始时间', type: 'error', duration: 2000 })
            return false
        }
        if (value.endTime === '') {
            Message({ showClose: true, message: '请输入结束时间', type: 'error', duration: 2000 })
            return false
        }
        if (new Date(value.startTime).getTime() > new Date(value.endTime).getTime()) {
            Message({ showClose: true, message: '开始时间不能大于结束时间', type: 'error', duration: 2000 })
            return false
        }
    } else if (type === 'Number') {
        let regxNumber = /^[0-9]*$/
        if (!regxNumber.test(value)) {
            Message({ showClose: true, message: displayname + '类型非法,应为数值类型', type: 'error', duration: 2000 })
            return false
        }
    } else if (type === 'Double') {
        let regxDouble = /^[-\+]?\d+(\.\d+)?$/
        if (!regxDouble.test(value)) {
            Message({
                showClose: true,
                message: displayname + '类型非法,应为双精度的浮点数',
                type: 'error',
                duration: 2000
            })
            return false
        }
    } else if (type === 'Integer') {
        let regxInteger = /^[-\+]?\d+(\.\d+)?$/
        if (!regxInteger.test(value)) {
            Message({ showClose: true, message: displayname + '类型非法,应为整型', type: 'error', duration: 2000 })
            return false
        }
    } else {
        if (value === '') {
            Message({ showClose: true, message: `请输入${displayname}`, type: 'error', duration: 2000 })
            return false
        }
    }
    return true
}
// 获取随机数
util.getRandom = len => {
    let randomStr = Math.random().toString()
    return randomStr.substring(2, 2 + len)
}
// 格式化时间
util.timestampToTime = timestamp => {
    return moment(timestamp).format('YYYY-MM-DD HH:mm:ss')
}
// 格式化日期
util.timestampToDate = timestamp => {
    return moment(timestamp).format('YYYY-MM-DD')
}
// 解析时间
util.formatDateTime = dateTime => {
    // var timestamp = Date.parse(new Date(dateTime))
    return moment(dateTime).format('X')
}
util.parseUriData = list => {
    // 创建一个对象命名为map
    let map = {}
    // 通过遍历把list中的元素放到map对象中
    list.forEach(function (item) {
        item.label = item.displayname
        if (!map[item.uri]) {
            // map中的'item.uri'属性指向list数组中的对象元素
            map[item.uri] = item
        }
    })
    // 再次遍历为了对map属性所指的对象进行处理
    list.forEach(function (item) {
        // 过滤父级uri不是0的元素
        if (item.parenturi != '') {
            // map[item.puri]为该元素的父级元素
            if (map[item.parenturi] != undefined) {
                map[item.parenturi].children
                    ? map[item.parenturi].children.push(item)
                    : (map[item.parenturi].children = [item])
            }
        }
    })
    // 过滤后仅剩下根节点
    return list.filter(function (item) {
        if (!item.hasOwnProperty('parenturi')) {
            return item
        }
    })
}
util.parseKeyData = list => {
    // 创建一个对象命名为map
    let map = {}
    // 通过遍历把list中的元素放到map对象中
    list.forEach(function (item) {
        item.label = item.displayname
        if (!map[item.ownkey]) {
            // map中的'item.uri'属性指向list数组中的对象元素
            map[item.ownkey] = item
        }
    })
    // 再次遍历为了对map属性所指的对象进行处理
    list.forEach(function (item) {
        // 过滤父级uri不是0的元素
        if (item.parentkey != '') {
            // map[item.puri]为该元素的父级元素
            if (map[item.parentkey] != undefined) {
                map[item.parentkey].children
                    ? map[item.parentkey].children.push(item)
                    : (map[item.parentkey].children = [item])
            }
        }
    })
    // 过滤后仅剩下根节点
    return list.filter(function (item) {
        if (!item.hasOwnProperty('parentkey')) {
            return item
        }
    })
}
// 把树结构的简单数据格式转变成标准数据格式
util.parseTreeData = list => {
    // 创建一个对象命名为map
    let map = {}
    // 通过遍历把list中的元素放到map对象中
    list.forEach(function (item) {
        item.label = item.displayname
        if (!map[item.id]) {
            // map中的'item.id'属性指向list数组中的对象元素
            map[item.id] = item
        }
    })
    // 再次遍历为了对map属性所指的对象进行处理
    list.forEach(function (item) {
        // 过滤父级id不是''的元素
        if (item.parentid != undefined) {
            // map[item.pid]为该元素的父级元素
            if (map[item.parentid] != undefined) {
                map[item.parentid].children
                    ? map[item.parentid].children.push(item)
                    : (map[item.parentid].children = [item])
            }
        }
    })
    // 过滤后仅剩下根节点
    return list.filter(function (item) {
        if (!item.hasOwnProperty('parentid')) {
            return item
        }
    })
}
// 将实例添加到监控
util.addToMonitoring = rowkey => {
    let MonitoringData = []
    if (Cookies.get('MonitoringData') === '' || Cookies.get('MonitoringData') === null || Cookies.get('MonitoringData') === undefined) {
        MonitoringData = []
    } else {
        MonitoringData = JSON.parse(Cookies.get('MonitoringData'))
    }
    // 判断是否重复
    let index = _.indexOf(MonitoringData, rowkey)
    if (index === -1) {
        MonitoringData.push(rowkey)
        Cookies.set('MonitoringData', JSON.stringify(MonitoringData))
        return true
    } else {
        return false
    }
}
// 将搜索结果添加到关联图
util.addToRelationGraph = params => {
    let RelationJyRk = []
    if (Cookies.get('RelationGraphData') === '' || Cookies.get('RelationGraphData') === null || Cookies.get('RelationGraphData') === undefined) {
        RelationJyRk = []
    } else {
        RelationJyRk = JSON.parse(Cookies.get('RelationGraphData'))
    }
    // 判断是否重复
    let index = _.findIndex(RelationJyRk, { rowkey: params.rowkey })
    if (index === -1) {
        RelationJyRk.push(params)
        Cookies.set('RelationGraphData', JSON.stringify(RelationJyRk))
        Message({ showClose: true, message: '添加成功', type: 'success', duration: 2000 })
        return true
    } else {
        Message({ showClose: true, message: '已添加', type: 'error', duration: 2000 })
        return false
    }
}
// 获取添加到关联图的对象
util.getObjectsInRelationGraph = () => {
    if (
        !(
            Cookies.get('RelationGraphData') === '' ||
            Cookies.get('RelationGraphData') === null ||
            Cookies.get('RelationGraphData') === undefined
        )
    ) {
        return JSON.parse(Cookies.get('RelationGraphData'))
    }
}
// 节流函数
util.debounce = (method, delay) => {
    let timer = null
    return function () {
        let _this = this
        let args = arguments
        clearTimeout(timer)
        timer = setTimeout(function () {
            method.apply(_this, args)
        }, delay)
    }
}
// 数组去重
util.uniq = (arr) => {
    let res = []
    let json = {}
    for (let i = 0; i < arr.length; i++) {
        if (!json[arr[i]]) {
            res.push(arr[i])
            json[arr[i]] = 1
        }
    }
    return res
}
export default util
